﻿#include "newWindow.h"


void newWindow(double x, double y, int current_offset_x, int current_offset_y, float offsetX, float offsetY, float total_scale) {

    STARTUPINFO si = { sizeof(si) };    //不需更改
    PROCESS_INFORMATION pi;             //不需更改

    // 计算各仪表的坐标和尺寸
    //lambda 函数
    auto calcInstrumentParams = [&](float base_x, float base_y, float base_size) -> std::tuple<int, int, int> {
        // 计算最终坐标
        const int final_x = current_offset_x + static_cast<int>(base_x * total_scale) - offsetX;
        const int final_y = current_offset_y + static_cast<int>(base_y * total_scale) - offsetY;
        // 计算最终尺寸
        const int final_size = static_cast<int>(base_size * total_scale);
        return { final_x, final_y, final_size };
        };

    //姿态仪
    auto [at_x, at_y, at_size] = calcInstrumentParams(1343.0f, 328.0f, 231.0f);
    if (x > at_x - at_size
        && x < at_x + at_size
        && y > at_y - at_size
        && y < at_y + at_size) {

        TCHAR szCommandLine[] = TEXT("\"..\\Bin\\x64\\Release\\AT.exe\"");
        // 创建进程
        BOOL success = CreateProcess(
            NULL,           // 应用程序名（从命令行解析）
            szCommandLine,  // 命令行参数
            NULL,           // 进程安全属性
            NULL,           // 线程安全属性
            FALSE,          // 不继承句柄
            0,              // 无特殊标志
            NULL,           // 使用父进程环境变量
            NULL,           // 使用父进程工作目录
            &si,            // 启动信息
            &pi             // 进程信息
        );

        // 关闭句柄（必须）
        // 关闭新进程的句柄，释放系统资源（整个进程）
        CloseHandle(pi.hProcess);
        // 关闭新进程主线程的句柄，释放系统资源（进程里的线程）
        CloseHandle(pi.hThread);
        //Sleep(50);
    }

    // 航向仪
    auto [hi_x, hi_y, hi_size] = calcInstrumentParams(1343.0f, 786.0f, 173.0f);
    if (x > hi_x - hi_size
        && x < hi_x + hi_size
        && y > hi_y - hi_size
        && y < hi_y + hi_size) {

        TCHAR szCommandLine[] = TEXT("\"..\\Bin\\x64\\Release\\HI.exe\"");
        // 创建进程
        BOOL success = CreateProcess(
            NULL,           // 应用程序名（从命令行解析）
            szCommandLine,  // 命令行参数
            NULL,           // 进程安全属性
            NULL,           // 线程安全属性
            FALSE,          // 不继承句柄
            0,              // 无特殊标志
            NULL,           // 使用父进程环境变量
            NULL,           // 使用父进程工作目录
            &si,            // 启动信息
            &pi             // 进程信息
        );

        // 关闭句柄（必须）
        // 关闭新进程的句柄，释放系统资源（整个进程）
        CloseHandle(pi.hProcess);
        // 关闭新进程主线程的句柄，释放系统资源（进程里的线程）
        CloseHandle(pi.hThread);
        //Sleep(50);
    } 
    
    // 空速表
    auto [ai_x, ai_y, ai_size] = calcInstrumentParams(915.0f, 332.0f, 171.0f);
    if (x > ai_x - ai_size
        && x < ai_x + ai_size
        && y > ai_y - ai_size
        && y < ai_y + ai_size) {

        TCHAR szCommandLine[] = TEXT("\"..\\Bin\\x64\\Release\\AI.exe\"");
        // 创建进程
        BOOL success = CreateProcess(
            NULL,           // 应用程序名（从命令行解析）
            szCommandLine,  // 命令行参数
            NULL,           // 进程安全属性
            NULL,           // 线程安全属性
            FALSE,          // 不继承句柄
            0,              // 无特殊标志
            NULL,           // 使用父进程环境变量
            NULL,           // 使用父进程工作目录
            &si,            // 启动信息
            &pi             // 进程信息
        );

        // 关闭句柄（必须）
        // 关闭新进程的句柄，释放系统资源（整个进程）
        CloseHandle(pi.hProcess);
        // 关闭新进程主线程的句柄，释放系统资源（进程里的线程）
        CloseHandle(pi.hThread);
        //Sleep(50);
    } 



    //转弯协调仪
    auto [tc_x, tc_y, tc_size] = calcInstrumentParams(915.0f, 786.0f, 171.0f);
    if (x > tc_x - tc_size
        && x < tc_x + tc_size
        && y > tc_y - tc_size
        && y < tc_y + tc_size) {

        TCHAR szCommandLine[] = TEXT("\"..\\Bin\\x64\\Release\\TC.exe\"");
        // 创建进程
        BOOL success = CreateProcess(
            NULL,           // 应用程序名（从命令行解析）
            szCommandLine,  // 命令行参数
            NULL,           // 进程安全属性
            NULL,           // 线程安全属性
            FALSE,          // 不继承句柄
            0,              // 无特殊标志
            NULL,           // 使用父进程环境变量
            NULL,           // 使用父进程工作目录
            &si,            // 启动信息
            &pi             // 进程信息
        );

        // 关闭句柄（必须）
        // 关闭新进程的句柄，释放系统资源（整个进程）
        CloseHandle(pi.hProcess);
        // 关闭新进程主线程的句柄，释放系统资源（进程里的线程）
        CloseHandle(pi.hThread);
        //Sleep(50);
    }


    //高度表
    auto [am_x, am_y, am_size] = calcInstrumentParams(1764.0f, 332.0f, 163.0f);
    if (x > am_x - am_size
        && x < am_x + am_size
        && y > am_y - am_size
        && y < am_y + am_size) {

        TCHAR szCommandLine[] = TEXT("\"..\\Bin\\x64\\Release\\AM.exe\"");
        // 创建进程
        BOOL success = CreateProcess(
            NULL,           // 应用程序名（从命令行解析）
            szCommandLine,  // 命令行参数
            NULL,           // 进程安全属性
            NULL,           // 线程安全属性
            FALSE,          // 不继承句柄
            0,              // 无特殊标志
            NULL,           // 使用父进程环境变量
            NULL,           // 使用父进程工作目录
            &si,            // 启动信息
            &pi             // 进程信息
        );

        // 关闭句柄（必须）
        // 关闭新进程的句柄，释放系统资源（整个进程）
        CloseHandle(pi.hProcess);
        // 关闭新进程主线程的句柄，释放系统资源（进程里的线程）
        CloseHandle(pi.hThread);
        //Sleep(50);
    }


    //垂直速度表
    auto [vs_x, vs_y, vs_size] = calcInstrumentParams(1764.0f, 786.0f, 171.0f);
    if (x > vs_x - vs_size
        && x < vs_x + vs_size
        && y > vs_y - vs_size
        && y < vs_y + vs_size) {

        TCHAR szCommandLine[] = TEXT("\"..\\Bin\\x64\\Release\\VS.exe\"");
        // 创建进程
        BOOL success = CreateProcess(
            NULL,           // 应用程序名（从命令行解析）
            szCommandLine,  // 命令行参数
            NULL,           // 进程安全属性
            NULL,           // 线程安全属性
            FALSE,          // 不继承句柄
            0,              // 无特殊标志
            NULL,           // 使用父进程环境变量
            NULL,           // 使用父进程工作目录
            &si,            // 启动信息
            &pi             // 进程信息
        );

        // 关闭句柄（必须）
        // 关闭新进程的句柄，释放系统资源（整个进程）
        CloseHandle(pi.hProcess);
        // 关闭新进程主线程的句柄，释放系统资源（进程里的线程）
        CloseHandle(pi.hThread);
        //Sleep(50);
    }

    //VOR1
    auto [vor1_x, vor1_y, vor1_size] = calcInstrumentParams(2223.0f, 332.0f, 175.0f);
    if (x > vor1_x - vor1_size
        && x < vor1_x + vor1_size
        && y > vor1_y - vor1_size
        && y < vor1_y + vor1_size) {

        TCHAR szCommandLine[] = TEXT("\"..\\Bin\\x64\\Release\\VOR1.exe\"");
        // 创建进程
        BOOL success = CreateProcess(
            NULL,           // 应用程序名（从命令行解析）
            szCommandLine,  // 命令行参数
            NULL,           // 进程安全属性
            NULL,           // 线程安全属性
            FALSE,          // 不继承句柄
            0,              // 无特殊标志
            NULL,           // 使用父进程环境变量
            NULL,           // 使用父进程工作目录
            &si,            // 启动信息
            &pi             // 进程信息
        );

        // 关闭句柄（必须）
        // 关闭新进程的句柄，释放系统资源（整个进程）
        CloseHandle(pi.hProcess);
        // 关闭新进程主线程的句柄，释放系统资源（进程里的线程）
        CloseHandle(pi.hThread);
        //Sleep(50);
    }


    //VOR2
    auto [vor2_x, vor2_y, vor2_size] = calcInstrumentParams(2223.0f, 788.0f, 175.0f);
    if (x > vor2_x - vor2_size
        && x < vor2_x + vor2_size
        && y > vor2_y - vor2_size
        && y < vor2_y + vor2_size) {

        TCHAR szCommandLine[] = TEXT("\"..\\Bin\\x64\\Release\\VOR2.exe\"");
        // 创建进程
        BOOL success = CreateProcess(
            NULL,           // 应用程序名（从命令行解析）
            szCommandLine,  // 命令行参数
            NULL,           // 进程安全属性
            NULL,           // 线程安全属性
            FALSE,          // 不继承句柄
            0,              // 无特殊标志
            NULL,           // 使用父进程环境变量
            NULL,           // 使用父进程工作目录
            &si,            // 启动信息
            &pi             // 进程信息
        );

        // 关闭句柄（必须）
        // 关闭新进程的句柄，释放系统资源（整个进程）
        CloseHandle(pi.hProcess);
        // 关闭新进程主线程的句柄，释放系统资源（进程里的线程）
        CloseHandle(pi.hThread);
        //Sleep(50);
    }


    //ADF
    auto [adf_x, adf_y, adf_size] = calcInstrumentParams(2223.0f, 1248.0f, 175.0f);
    if (x > adf_x - adf_size
        && x < adf_x + adf_size
        && y > adf_y - adf_size
        && y < adf_y + adf_size) {

        TCHAR szCommandLine[] = TEXT("\"..\\Bin\\x64\\Release\\ADF.exe\"");
        // 创建进程
        BOOL success = CreateProcess(
            NULL,           // 应用程序名（从命令行解析）
            szCommandLine,  // 命令行参数
            NULL,           // 进程安全属性
            NULL,           // 线程安全属性
            FALSE,          // 不继承句柄
            0,              // 无特殊标志
            NULL,           // 使用父进程环境变量
            NULL,           // 使用父进程工作目录
            &si,            // 启动信息
            &pi             // 进程信息
        );

        // 关闭句柄（必须）
        // 关闭新进程的句柄，释放系统资源（整个进程）
        CloseHandle(pi.hProcess);
        // 关闭新进程主线程的句柄，释放系统资源（进程里的线程）
        CloseHandle(pi.hThread);
        //Sleep(50);
    }

    //PHI 仪表(引擎转速表)
    auto [phi_x, phi_y, phi_size] = calcInstrumentParams(1763.0f, 1248.0f, 171.0f);
    if (x > phi_x - phi_size
        && x < phi_x + phi_size
        && y > phi_y - phi_size
        && y < phi_y + phi_size) {

        TCHAR szCommandLine[] = TEXT("\"..\\Bin\\x64\\Release\\PHI.exe\"");
        // 创建进程
        BOOL success = CreateProcess(
            NULL,           // 应用程序名（从命令行解析）
            szCommandLine,  // 命令行参数
            NULL,           // 进程安全属性
            NULL,           // 线程安全属性
            FALSE,          // 不继承句柄
            0,              // 无特殊标志
            NULL,           // 使用父进程环境变量
            NULL,           // 使用父进程工作目录
            &si,            // 启动信息
            &pi             // 进程信息
        );

        // 关闭句柄（必须）
        // 关闭新进程的句柄，释放系统资源（整个进程）
        CloseHandle(pi.hProcess);
        // 关闭新进程主线程的句柄，释放系统资源（进程里的线程）
        CloseHandle(pi.hThread);
        //Sleep(50);
    }

    // FUI(油量表)
    auto [fu_x, fu_y, fq_size] = calcInstrumentParams(232.0f, 786.0f, 111.0f);
    if (x > fu_x - fq_size
        && x < fu_x + fq_size
        && y > fu_y - fq_size
        && y < fu_y + fq_size) {

        TCHAR szCommandLine[] = TEXT("\"..\\Bin\\x64\\Release\\FUI.exe\"");
        // 创建进程
        BOOL success = CreateProcess(
            NULL,           // 应用程序名（从命令行解析）
            szCommandLine,  // 命令行参数
            NULL,           // 进程安全属性
            NULL,           // 线程安全属性
            FALSE,          // 不继承句柄
            0,              // 无特殊标志
            NULL,           // 使用父进程环境变量
            NULL,           // 使用父进程工作目录
            &si,            // 启动信息
            &pi             // 进程信息
        );

        // 关闭句柄（必须）
        // 关闭新进程的句柄，释放系统资源（整个进程）
        CloseHandle(pi.hProcess);
        // 关闭新进程主线程的句柄，释放系统资源（进程里的线程）
        CloseHandle(pi.hThread);
        //Sleep(50);
    }

    // TFF(排气温度燃油)
    auto [ff_x, ff_y, ff_size] = calcInstrumentParams(533.0f, 786.0f, 111.0f);
    if (x > ff_x - ff_size
        && x < ff_x + ff_size
        && y > ff_y - ff_size
        && y < ff_y + ff_size) {

        TCHAR szCommandLine[] = TEXT("\"..\\Bin\\x64\\Release\\TFF.exe\"");
        // 创建进程
        BOOL success = CreateProcess(
            NULL,           // 应用程序名（从命令行解析）
            szCommandLine,  // 命令行参数
            NULL,           // 进程安全属性
            NULL,           // 线程安全属性
            FALSE,          // 不继承句柄
            0,              // 无特殊标志
            NULL,           // 使用父进程环境变量
            NULL,           // 使用父进程工作目录
            &si,            // 启动信息
            &pi             // 进程信息
        );

        // 关闭句柄（必须）
        // 关闭新进程的句柄，释放系统资源（整个进程）
        CloseHandle(pi.hProcess);
        // 关闭新进程主线程的句柄，释放系统资源（进程里的线程）
        CloseHandle(pi.hThread);
        //Sleep(50);
    }

    // VBT(电流压力）
    auto [vbt_x, vbt_y, vbt_size] = calcInstrumentParams(533.0f, 1101.0f, 120.0f);
    if (x > vbt_x - vbt_size
        && x < vbt_x + vbt_size
        && y > vbt_y - vbt_size
        && y < vbt_y + vbt_size) {

        TCHAR szCommandLine[] = TEXT("\"..\\Bin\\x64\\Release\\VBT.exe\"");
        // 创建进程
        BOOL success = CreateProcess(
            NULL,           // 应用程序名（从命令行解析）
            szCommandLine,  // 命令行参数
            NULL,           // 进程安全属性
            NULL,           // 线程安全属性
            FALSE,          // 不继承句柄
            0,              // 无特殊标志
            NULL,           // 使用父进程环境变量
            NULL,           // 使用父进程工作目录
            &si,            // 启动信息
            &pi             // 进程信息
        );

        // 关闭句柄（必须）
        // 关闭新进程的句柄，释放系统资源（整个进程）
        CloseHandle(pi.hProcess);
        // 关闭新进程主线程的句柄，释放系统资源（进程里的线程）
        CloseHandle(pi.hThread);
        //Sleep(50);
    }

    // OTP(油温油压）
    auto [otp_x, otp_y, otp_size] = calcInstrumentParams(232.0f, 1101.0f, 120.0f);
    if (x > otp_x - otp_size
        && x < otp_x + otp_size
        && y > otp_y - otp_size
        && y < otp_y + otp_size) {

        TCHAR szCommandLine[] = TEXT("\"..\\Bin\\x64\\Release\\OTP.exe\"");
        // 创建进程
        BOOL success = CreateProcess(
            NULL,           // 应用程序名（从命令行解析）
            szCommandLine,  // 命令行参数
            NULL,           // 进程安全属性
            NULL,           // 线程安全属性
            FALSE,          // 不继承句柄
            0,              // 无特殊标志
            NULL,           // 使用父进程环境变量
            NULL,           // 使用父进程工作目录
            &si,            // 启动信息
            &pi             // 进程信息
        );

        // 关闭句柄（必须）
        // 关闭新进程的句柄，释放系统资源（整个进程）
        CloseHandle(pi.hProcess);
        // 关闭新进程主线程的句柄，释放系统资源（进程里的线程）
        CloseHandle(pi.hThread);
        //Sleep(50);
    }

    //CNM 时间表
    auto [cnm_x, cnm_y, cnm_size] = calcInstrumentParams(533.0f, 416.0f, 122.0f);

    if (x > cnm_x - cnm_size
        && x < cnm_x + cnm_size
        && y > cnm_y - cnm_size
        && y < cnm_y + cnm_size) {

        TCHAR szCommandLine[] = TEXT("\"..\\Bin\\x64\\Release\\CNM.exe\"");
        // 创建进程
        BOOL success = CreateProcess(
            NULL,           // 应用程序名（从命令行解析）
            szCommandLine,  // 命令行参数
            NULL,           // 进程安全属性
            NULL,           // 线程安全属性
            FALSE,          // 不继承句柄
            0,              // 无特殊标志
            NULL,           // 使用父进程环境变量
            NULL,           // 使用父进程工作目录
            &si,            // 启动信息
            &pi             // 进程信息
        );

        // 关闭句柄（必须）
        // 关闭新进程的句柄，释放系统资源（整个进程）
        CloseHandle(pi.hProcess);
        // 关闭新进程主线程的句柄，释放系统资源（进程里的线程）
        CloseHandle(pi.hThread);
        //Sleep(50);
    }
}